Generally stated, a computer-implemented editing system is a system operable for creating and altering electronic documents such as letters, statistical analyses, e-mail messages, flow-charts, and the like. There are a wide variety of editing programs available that allow conventional personal computers to function as sophisticated computer-implemented editing systems. For example, specialized editing programs are available for creating and altering word processing documents, spreadsheets, databases, e-mail messages, and audio-visual presentations. Developing and selling various types of editing programs is a highly competitive market. The participants in this market therefore continually strive to develop innovations for their editing programs that the purchasing public finds desirable.
Two types of innovations have been particularly successful in the market for editing programs. The first type are innovations that help users create error free documents, such as spelling and grammar correction utilities. The second type are innovations that make editing systems easier and faster to use, such as tool bars, pop-up windows, pull-down menus, and other types of user-friendly interfaces. Despite the efforts of program developers to improve these aspects of editing programs, significant drawbacks persist in the operation of conventional editing programs.
To illustrate one such drawback of conventional editing programs, consider a word processing program with a post-processing spelling correction utility. To use this type of editing system, an author types all or part of a document. The author may stop the data input process at any point and invoke a spelling correction utility. This utility scans the document word by word and compares each word to the words in the program's spelling dictionary. The spelling correction utility stops scanning when it encounters a word that is not found in the program's spelling dictionary, which word the utility tags as a potentially misspelled word. The potentially misspelled word is typically displayed to the author in a spelling correction user interface, such as a pop-up window, along with a set of selectable options offering likely choices for correct spellings taken from the program's spelling dictionary. The spelling correction user interface typically includes a number of selectable menu items, such as "replace," "replace all," "ignore," "ignore all," "delete," and "add to spelling dictionary." The author must then interact with the user interface, for example by selecting one of the menu items, before the spelling correction utility continues scanning through the document.
This type of spelling correction utility can be cumbersome to use because user interaction is required before the document is altered. Consider, for example, a document that includes the data pattern "int he." The data entry "int he" is almost certainly a data entry error for "in the." It would therefore be convenient for the spelling correction utility to recognize the data pattern "int he" as a potential misspelling and to provide the user with a selectable option to replace "int he" with "in the." The conventional spelling correction utility, however, identifies the word "int" as a misspelling, and provides the user with a selectable option to replace all instances of "int" with "in." If the user selects to replace all instances of "int" with "in," the text is left reading "in he" instead of "in the," which is not what the user wants. Moreover, the spelling correction utility is subsequently unable to detect the phrase "in he" as a data entry error because both words "in" and "he" correspond to valid words in the spelling dictionary. The user must therefore go through the process of searching throughout the document for occurrences of "in he" and manually changing the text to read "in the" in each instance. Most users find this to be an aggravating and time consuming process.
Another shortcoming of these conventional editing programs is that certain data patterns that are almost certainly data entry errors go undetected. This happens when each word of the data entry corresponds to a valid spelling, and there are no grammatical errors that can be detected by the grammar correcting utility. Sometimes, a data entry error of this type results from a very simple typing error that produces an erroneous data pattern that conveys an unfortunate and potentially embarrassing meaning. For example, a user may type "diner time" intending to type "dinner time." Both a conventional spelling correction utility and a conventional grammar correction utility will not detect this particular error. To make matters worse, this type of error is precisely the type that humans find difficult to pick up when proof reading. As a result, this type of data entry error often goes undetected. Other potentially embarrassing data entry errors of this type include "wreck havoc" for "wreak havoc," and "the baby's basinet" a medieval helmet! for "the baby's bassinet." Errors of this type are so easy to make inadvertently and then overlook when proof reading that they occur with disturbing regularity.
Another shortcoming of conventional editing programs is that they do not detect certain data entries that may well be what the user intended to type, but are nevertheless almost certainly incorrect. This type of data entry error may be particularly troublesome for an author having a less-than-perfect grasp of English syntax, such as an author for whom English is a second language. For example, many people are simply unaware the correct usage of "its" and "it's" due to its (not it's) unusual possessive form. Time after time, a user may type incorrect phrases such as "it's name." Similarly, the terms "your" and "you're" are frequently used incorrectly. Other examples of common errors of this type are "gorilla warfare" for "guerrilla warfare," "might of been" for "might have been," and "when ever" for "whenever." Human languages are, in these and many other instances, very tricky. Although these data entries may be correct in very rare circumstances, they are almost always erroneous. It would therefore be desirable for an editing system to be operable for detecting data entry errors of this type.
Yet another shortcoming of conventional editing programs is that they inefficiently handle a large class of data patterns that are, more likely not, data entry errors. For this class of data patterns, even if the editing program detects the data pattern and suggests the most likely correction, a relatively large number of user interactions are required to confirm the corrections. A smaller number of user interactions would be required, for example, if the editing program could automatically correct these data patterns. User interaction could then be reserved for the relatively small number of instances in which the author intends the data patterns and must therefore reverse the automatic corrections.
To illustrate, consider the data pattern "revelant." Assume that an author has typed this data pattern in ninety-nine documents intending to type "relevant," and that in one document (e.g, when the author was writing a document describing recurring spelling errors) the author actually intended to write "revelant." For an editing program that requires user interaction to confirm suggested corrections, user interaction is required in ninety-nine documents to confirm the correction of "revelant" to "relevant." For an editing program that makes this correction automatically, on the other hand, user interaction is only required to reverse the automatic correction (i.e., to return "relevant" to "revelant") in the one document that the user actually intended to write "revelant." An automatic correction utility would thus greatly reduce the number of user interactions.
There is, therefore, a need for an improved editing system that detects and corrects common data entry errors that are not detected by conventional editing systems. There is also a need for an improved editing system that automatically corrects common data entry errors that are not detected by conventional editing systems.